🧡 02. 람다(lambda) | 함수형 인터페이스(Predicate, Consumer, Function)

💎 람다 (lambda)

람다 표현식은 메소드로 전달할 수 있는 익명 함수를 단순화 한 것.

람다의 특징은 아래와 같다.

TIP

1. 익명
   • 보통의 메소드와 달리 이름이 없어서 익명!
2. 함수
   • 특정 클래스에 종속되지 않아서 함수라고 부른다.
3. 전달
   • 람다 표현식을 메소드 인수로 전달하거나 변수로 저장할 수 있다.
4. 간결성
   • 익명 클래스처럼 많은 자질구레한 코드를 구현할 필요가 없다.

🍎 사과 클래스

---

무게와 색상 정보가 담긴 사과 클래스 생성

package javaStudy.mda02;

/**
 * 사과
 */
public class Apple {
    public enum Color {
        RED,
        GREEN
    }

    Color color;
    Integer weight;

    public Apple(Color color, int weight) {
        this.color = color;
        this.weight = weight;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "color=" + color +
                ", weight=" + weight +
                '}';
    }
}

기존 코드

---

Comparator<Apple> byWeight = new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
};

람다 적용 코드

---

Comparator<Apple> byWeight = (Apple o1, Apple o2) -> o1.getWeight().compareTo(o2.getWeight());

💎 함수형 인터페이스

Predicate<T> 와 같은 게 함수형 인터페이스다. 많은 디폴트 메소드(인터페이스의 메소드를 구현하지 않은 클래스를 고려해서 기본 구현을 제공하는 바디를 포함하는 메소드)가 있더라도 추상메소드가 오직 하나면 함수형 인터페이스다.

예를 들어 아래와 같은 것들이 있다.

Predicate

---

test 라는 추상 메서드를 정의하며 boolean을 반환한다.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

// 활용 예제
package javaStudy.mda03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class MainMethod {

    public static void main(String[] args) {
        List<String> listOfStrings = new ArrayList<>(Arrays.asList("apple","banana","melon", ""));

        Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
        
        // [apple, banana, melon]
        List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        for (T t : list) {
            if (p.test(t)) {
                results.add(t);
            }
        }
        return results;
    }
}

Consumer

---

accept 라는 추상메서드를 정의하며 void를 반환한다.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

// 활용 예제
package javaStudy.mda03;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        forEach(
            Arrays.asList(1,2,3,4,5),
                (Integer i) -> System.out.println(i)
        );
    }

    public static <T> void forEach(List<T> list, Consumer<T> c) {
        for(T t : list) {
            c.accept(t);
        }
    }
}

Function

---

apply라는 추상메서드를 정의하며, 제네릭 형식 T 객체를 인수로 받아 R 객체를 반환한다.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

// 활용
package javaStudy.mda03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        List<Integer> l = map(
                Arrays.asList("labmdas", "in", "action"),
                (String s) -> s.length()
        );
    }

    public static <T, R> List<R> map(List<T> list, Function<T, R> f) {
        List<R> result = new ArrayList<>();
        for(T t : list) {
            result.add(f.apply(t));
        }
        return result;
    }
}

💎 메소드 참조

기존코드

---

appleList.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

메소드 참조

---

appleList.sort(Comparator.comparing(Apple::getWeight));
appleList.sort(Comparator.comparing(Apple::getWeight).reversed()); // 내림차순
appleList.sort(Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor)); // 무게가 같으면 색상별로 정렬

💎 Predicate 조합

apple List 생성 및 filter 메소드 생성

---

public static void main(String[] args) {
        List<Apple> appleList = Arrays.asList(
                new Apple(Apple.Color.RED, 180),
                new Apple(Apple.Color.GREEN, 100),
                new Apple(Apple.Color.RED, 100),
                new Apple(Apple.Color.GREEN, 350),
                new Apple(Apple.Color.RED, 400)
        );
}

public static <T> List<T> filter(List<T> list, java.util.function.Predicate<T> p) {
    List<T> results = new ArrayList<>();
    for (T t : list) {
        if (p.test(t)) {
            results.add(t);
        }
    }
    return results;
}

기존 Predicate

---

// [Apple{color=GREEN, weight=100}, Apple{color=GREEN, weight=350}]
Predicate<Apple> greenApplePredicate = (apple) -> Apple.Color.GREEN.equals(apple.getColor());
filter(appleList, greenApplePredicate);

negate()

---

기존 Predicate 반전

// [Apple{color=RED, weight=180}, Apple{color=RED, weight=100}, Apple{color=RED, weight=400}]
Predicate<Apple> notGreenApple = greenApplePredicate.negate();
filter(appleList, notGreenApple);

and

---

Predicate 연결

// [Apple{color=GREEN, weight=350}]
Predicate<Apple> greenAndHeavyApple = greenApplePredicate.and(apple -> apple.getWeight() > 150);
filter(appleList, greenAndHeavyApple);

or

---

Predicate 추가조건

// [Apple{color=RED, weight=180}, Apple{color=RED, weight=100}, Apple{color=GREEN, weight=350}, Apple{color=RED, weight=400}]
Predicate<Apple> greenAndHeavyAppleOrRed = greenApplePredicate.and(apple -> apple.getWeight() > 150).or(apple -> Apple.Color.RED.equals(apple.getColor()));
filter(appleList, greenAndHeavyAppleOrRed);

Reference

---

모던 자바 인 액션 (한빛미디어)